#PaquetReglesReductionsBerthelot        ;  15/06/94  ;
	
	=RD(Reussite Reduction Vrai)

	=EstVrai(Fin)
	=EstFaux(ContinuerActionUn)
	=EstFaux(VerifierSiOnPeutContinuer)
	=EstFaux(AjouterUnePlace)
	=EstFaux(AjouterLesArcsEnEntreeDUnePlace)
	=EstFaux(AjouterLesArcsEnSortieDUnePlace)
	=EstFaux(AjouterUneTransition)
	=EstFaux(AjouterLesArcsEnEntreeDUneTransition)
	=EstFaux(AjouterLesArcsEnSortieDUneTransition)

$ RTransitionNeutre
  
  Si
	(Existe ! :t)
	Vrai(ReductionTest)
	Vrai(NeutreTest)
	RE(PlaceTransition :t Transition)
	RC(VecEgal 22 Pre :t Post :t)    ;  Pre(.,t) = Post(.,t)  ;
  Alors
	Imprime(TransitionNeutre :t)
	RA(Detruire :t Transition)
	RA(QuestionEtTexte 103 Vrai)
	EstFaux(ReductionTest)

$ RTransitionsIdentiques

  Si 
	(Existe :p)
	(Existe ! :t1)
	(Existe ! :t2)
	Vrai(ReductionTest)
	Vrai(TransitionsIdentiquesTest)
	RE(Pre :p :t1)
	RE(Pre :p :t2)
	Inf(:t1 :t2)
	RC(VecEgal 22 Pre :t1 Pre :t2)
	RC(VecEgal 22 Post :t1 Post :t2)
  Alors
	Imprime(TransitionsIdentiques :t1 :t2)
	RA(Detruire :t2 Transition)
	RA(QuestionEtTexte 116 Vrai)
	EstFaux(ReductionTest)

$ RPlaceImpliciteCasRestreint

  Si
	(Existe ! :p)
	(Existe :m)
	(PourTous :v RE(Pre :p :t) ME(Pre :p :t :v))
	Vrai(ReductionTest)
	Vrai(DimpliciteTest)
	RE(PlaceTransition :p Place)
	RC(VecEgal 11 Pre :p Post :p)
	RE(Marking m0 :p)
	ME(Marking m0 :p :m)
	InfEgal(:v :m)
  Alors
	Imprime(PlaceImpliciteCasRestreint :p)
	RA(Detruire :p Place)
	RA(QuestionEtTexte 100 Vrai)
	EstFaux(ReductionTest)

$ RPlacesIdentiques
  
  Si
	(Existe ! :p1)
	(Existe ! :p2)
	(Existe :t)
	(Existe :n)
	Vrai(ReductionTest)
	Vrai(PlacesEquivalentesTest)
	Non Egal(:p1 :p2)
	RE(Pre :p1 :t)                   ;  soit 2 Places ayant une Transition t commune en sortie  ;
	RE(Pre :p2 :t)
	ME(Marking m0 :p1 :n)            ;  ces 2 Places ont :  ;
	ME(Marking m0 :p2 :n)            ;  - meme marquage initial  ;
	RC(VecEgal 11 Pre :p1 Pre :p2)   ;  - meme Transition en sortie (valuation)  ;
	RC(VecEgal 11 Post :p1 Post :p2) ;  - meme Transition en entree (valuation)  ;
  Alors
	Imprime(PlacesIdentiques :p1 :p2)
	RA(Detruire :p2 Place)
	RA(QuestionEtTexte 117 Vrai)
	EstFaux(PuisJeReduire)

$ RPlacesEquivalentes
  
  Si
	(Existe ! :p1)
	(Existe ! :p2)
	(Existe :r1)
	(Existe :r2)
	(Existe :t1)
	(Existe :t2)        
	(Existe :npe)
	(Existe :npo)
	(Existe :Np1)
	(Existe :Np2)
	(Existe :NpS)
	(Existe :Num)
	(Existe :Sui)
	(PourTous :q1 non Egal(:q1 :p1) RE(Pre :pq1 :t1) OuEgal(:q1 :pq1 :pq2) non Egal(:q1 :p2) RE(Pre :pq2 :t2))
	(Existe :v1)
	(PourTous :q2 non Egal(:q2 :p1) RE(Post :pq1 :t1) OuEgal(:q2 :pq1 :pq2) non Egal(:q2 :p2) RE(Post :pq2 :t2))
	(Existe :v2)
	Vrai(ReductionTest)
	Vrai(PlacesEquivalentesTest)
	Inf(:p1 :p2)
	Inf(:t1 :t2)
	RX1(Pre :p1 :t1)
	RX1(Pre :p2 :t2)
	ME(Pre :p1 :t1 1)
	ME(Pre :p2 :t2 1)
	ME(Pre :q1 :t1 :v1)
	ME(Pre :q1 :t2 :v1)
	ME(Post :q2 :t1 :v2)
	ME(Post :q2 :t2 :v2)
	RE(Post :p1 :r1)
	RE(Post :p2 :r2)
	VR(:npe Pre :t1)
	VR(:npe Pre :t2)
	VR(:npo Post :t1)
	VR(:npo Post :t2)
	RE(Name :p1 :Np1)
	RE(Name :p2 :Np2)
	GenNom(:NpS :Np1 :Np2)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)

  Alors
	Imprime(PlacesEquivalentes :p1 :p2)
	RA(PlaceTransition :Sui Place)
	MV(VecPlus 11 Pre :Sui Pre :p1)
	MV(VecPlus 11 Pre :Sui Pre :p2)
	MV(VecPlus 11 Post :Sui Post :p1)
	MV(VecPlus 11 Post :Sui Post :p2)
	RA(Ajouter :Sui Place)
	RA(Name :Sui :NpS)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(Detruire :p1 Place)
	RA(Detruire :p2 Place)
	EstVrai(AjouterUnePlace)
	EstVrai(AjouterLesArcsEnEntreeDUnePlace)
	EstVrai(AjouterLesArcsEnSortieDUnePlace)
	RA(QuestionEtTexte 117 Vrai)
	EstFaux(ReductionTest)

$ RAgglomerationLateraleHauteTransitions ;  tc precede tg et td  ;

  Si
	(Existe ! :td)
	(Existe ! :tg)
	(Existe :pd)
	(Existe :pg)
	(Existe :ptd)
	(Existe :ptg)
	(Existe :tc)
	(Existe :v)
	(Existe :NpG)
	(Existe :NpD)
	(Existe :NpC)
	(Existe :Num)
	(Existe :Sui)
	Vrai(ReductionTest)
	Vrai(AgglomerationLateraleTest)
	Inf(:pd :pg)                     ;  pg et pd sont deux Places distinctes  ;
	Inf(:tg :td)                     ;  tg et td sont deux Transitions distinctes  ;
	RX1(Post :pg :tc)                ;  tc seule Transition ayant pg pour sortie  ;
	ME(Post :pg :tc 1)
	RX1(Post :pd :tc)                ;  tc seule Transition ayant pd pour sortie  ;
	ME(Post :pd :tc 1)
	RE(Post :ptd :td)                ;  td a au moins une sortie  ;
	RE(Post :ptg :tg)                ;  tg a au moins une sortie  ;
	RX1(Pre :pg :tg)                 ;  tg seule Transition ayant pg en entree  ;
	ME(Pre :pg :tg 1)                
	RX1(Pre :pd :td)                 ;  td seule Transition ayant pd en entree  ;
	ME(Pre :pd :td 1)
	VR(1 Pre :tg)                    ;  tg n'a qu'une seule entree  ;
	VR(1 Pre :td)                    ;  td n'a qu'une seule entree  ;
	ME(Marking m0 :pg :v)           ;  pg et pd ont meme marquage initial  ;
	ME(Marking m0 :pd :v)
	RE(Name :tg :NpG)
	RE(Name :td :NpD)
	GenNom(:NpC :NpG :NpD)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)

  Alors
	Imprime(AgglomerationLaterale :tg :td)
	RA(PlaceTransition :Sui Transition)
	MV(VecPlus 22 Pre :Sui Pre :tg)
	MV(VecPlus 22 Pre :Sui Pre :td)
	MV(VecPlus 22 Post :Sui Post :tg)
	MV(VecPlus 22 Post :Sui Post :td)
	RA(Ajouter :Sui Transition)
	RA(Name :Sui :NpC)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(Detruire :tg Transition)
	RA(Detruire :td Transition)
	EstVrai(AjouterUneTransition)
	EstVrai(AjouterLesArcsEnEntreeDUneTransition)
	EstVrai(AjouterLesArcsEnSortieDUneTransition)
	RA(QuestionEtTexte 118 Vrai)
	EstFaux(ReductionTest)

$ RAgglomerationLateraleBasseTransitions ;  tg et td precedent tc  ;

  Si
	(Existe ! :td)
	(Existe ! :tg)
	(Existe :pd)
	(Existe :pg)
	(Existe :ptd)
	(Existe :ptg)
	(Existe :tc)
	(Existe :v)
	(Existe :NpG)
	(Existe :NpD)
	(Existe :NpC)
	(Existe :Num)
	(Existe :Sui)
	Vrai(ReductionTest)
	Vrai(AgglomerationLateraleTest)
	Inf(:pd :pg)                     ;  pg et pd sont deux Places distinctes  ;
	Inf(:tg :td)                     ;  tg et td sont deux Transitions distinctes  ;
	RX1(Pre :pg :tc)                 ;  tc seule Transition ayant pg pour entree  ;
	ME(Pre :pg :tc 1)
	RX1(Pre :pd :tc)                 ;  tc seule Transition ayant pd pour entree  ;
	ME(Pre :pd :tc 1)
	RE(Post :ptd :td)                ;  td a au moins une entree  ;
	RE(Post :ptg :tg)                ;  tg a au moins une entree  ;
	RX1(Post :pg :tg)                ;  tg seule Transition ayant pg en sortie  ;
	ME(Post :pg :tg 1)
	RX1(Post :pd :td)                ;  td seule Transition ayant pd en entree  ;
	ME(Post :pd :td 1)
	VR(1 Pre :tg)                    ;  tg n'a qu'une seule entree  ;
	VR(1 Pre :td)                    ;  td n'a qu'une seule entree  ;
	ME(Marking m0 :pg :v)           ;  pg et pd ont meme marquage initial  ;
	ME(Marking m0 :pd :v)
	RE(Name :tg :NpG)
	RE(Name :td :NpD)
	GenNom(:NpC :NpG :NpD)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)

  Alors
	Imprime(AgglomerationLaterale :tg :td)
	RA(PlaceTransition :Sui Transition)
	MV(VecPlus 22 Pre :Sui Pre :tg)
	MV(VecPlus 22 Pre :Sui Pre :td)
	MV(VecPlus 22 Post :Sui Post :tg)
	MV(VecPlus 22 Post :Sui Post :td)
	RA(Ajouter :Sui Transition)
	RA(Name :Sui :NpC)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(Detruire :tg Transition)
	RA(Detruire :td Transition)
	EstVrai(AjouterUneTransition)
	EstVrai(AjouterLesArcsEnEntreeDUneTransition)
	EstVrai(AjouterLesArcsEnSortieDUneTransition)
	RA(QuestionEtTexte 118 Vrai)
	EstFaux(ReductionTest)

[ ;  Debut PreAgglomeration de Transitions  ;

$ RPreAgglomerationTransitions

  AussitotQue
	(Existe ! :p)
	(Existe ! :h)
	(PourTous :f RE(Pre :p :f))
	Vrai(ReductionTest)
	Vrai(PreAgglomerationTest)
	Non RE(Marking m0 :p)           ;  a) p est non marquee  ;
	RX1(Post :p :h)                  ;  b) seule h est entree de p  ;
	VR(1 Post :h)                    ;  c) h ne possede qu'une seule sortie  ;
	ME(Post :p :h 1)                 ;  d) valuation 1 entre h et p  ;
	Non RE(Pre :p :h)                ;  e) p n'est pas entree de h  ;
	RY(Pre :h)                       ;  f) h a au moins une entree  ;
	ME(Pre :p :f 1)                  ;  h) toute Transition de F prend 1 marque dans p  ;
	Non RE(post :p :f)               ;  i) aucune Transition de F ne met de marque dans p  ;
	RYn(Pre :h)                      ;  j) les entrees de h n'ont pas d'autre sortie que h  ;
	RE(Pre :p :f)                    ;  k) p a au moins une Transition f en sortie  ;
  Alors
	Imprime(PreAgglomeration :p :h)
	RA(Detruire :p Place)
	RA(Detruire :h Transition)
	EstVrai(AjouterLesArcsEnSortieDUnePlace)
	RA(QuestionEtTexte 102 Vrai)
	EstFaux(ReductionTest)

$ RActionUnPreAgglomerationTransitions

  Si
	RE(Detruire :p Place)
	RE(Detruire :h Transition)
	RE(Pre :p :f)
  Alors
	MV(VecPlus 22 Pre :f Pre :h)    

$ RActionDeuxPreAgglomerationTransitions

  Si
	RE(Detruire :h Transition)
	RE(Pre :q :h)
  Alors
	RA(Ajouter :q Place)

] ;  Fin PreAgglomeration de Transitions  ;

[ ;  Debut PostAgglomeration de Transitions  ;

$ RPostAgglomerationTransitions
  
  AussitotQue
	(Existe ! :p)
	(Existe :t)
	(Existe :m)
	(PourTous :f RE(Pre :p :f))
	(PourTous :h RE(Post :p :h))
	(Existe :mh)
	(Existe :n)
	Vrai(ReductionTest)
	Vrai(PostAgglomerationTest)
	Non RE(Marking m0 :p)           ;  a) p est non marquee  ;
	RE(Pre :p :t)
	ME(Pre :p :t :m)                 ;  b) meme valuation m pour tout arc en sortie de p ;
	RXn(Pre :p)                      ;  c) les successeurs de p ont p comme unique predecesseur  ;
	ME(Pre :p :f :m)                 ;  d) les Transitions de F ont m comme valuation  ;
	Non RE(Post :p :f)               ;  e) p n'est pas sortie de F  ;
	RE(Post :t)                      ;  f) une Transition de F au moins a une sortie  ;
	Non RE(Pre :p :h)                ;  g) p n'est pas une entree de h  ;
	ME(Post :p :h :mh)               ;  h) valuation mh pour un arc en sortie d'une Transition h  ;
	Prod(:mh :m :n)                  ;  i) mh est un multiple de m  ;
	RE(Post :p :h)                   ;  j) p a au moins une Transition h en entree  ;
  Alors
	Imprime(PostAgglomeration :p)
	RA(Detruire :p Place)
	EstVrai(AjouterUneTransition)
	EstVrai(AjouterLesArcsEnEntreeDUneTransition)
	EstVrai(AjouterLesArcsEnSortieDUneTransition)
	RA(QuestionEtTexte 105 Vrai)
	EstFaux(ReductionTest)
	EstVrai(ContinuerActionUn)

$ RActionPostUnAgglomerationTransitions

  Si
	(Existe :p)
	(Existe ! :h)
	(Existe ! :f)
	Vrai(ContinuerActionUn)
	RE(Detruire :p Place)
	Non RE(DejaFait :h :f)
	RE(Post :p :h)
	RE(Pre :p :f)	
  Repete
	RA(DejaFait :h :f)

$ RActionPostDeuxAgglomerationTransitions

  Si
	(Existe ! :h)
	(Existe ! :f)
	(Existe :NpH)
	(Existe :NpF)
	(Existe :NpC)
	(Existe :Num)
	(Existe :Sui)
	RE(DejaFait :h :f)
	RE(Name :h :NpH)
	RE(Name :f :NpF)
	GenNom(:NpC :NpH :NpF)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)
  Repete
	EstFaux(ContinuerActionUn)
	RA(PlaceTransition :Sui Transition)
	MV(VecPlus 22 Pre :Sui Pre :h)
	MV(VecPlus 22 Post :Sui Post :h)
	MV(VecPlus 22 Post :Sui Post :f)
	RA(Ajouter :Sui Transition)
	RA(Name :Sui :NpC)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(Detruire :f Transition)
	RA(Detruire :h Transition)
	RD(DejaFait :h :f)

] ;  Fin PostAgglomeration de Transitions  ;

[ ;  Debut Place Implicite par Semi-Flot  ;

$ RPlaceImpliciteParSemiFlot

  Si
	Vrai(ReductionTest)
	Vrai(ImpliciteTest)
	RE(PlaceTransition)
	RE(PlaceTransition :p Place)
	RE(PlaceTransition :t Transition)
	ME(Marking m0 :p :v)   
  Alors
	ServicExt(psf PlaceTransition Place Transition Marking Pre Post relnum ImpliciteResultat)
	EstFaux(ReductionTest)

$ RActionPlaceImpliciteParSemiFlot

  SiPasAutre
	RE(ImpliciteResultat :p 1)
  Alors
	Imprime(PlaceImpliciteParSemiFlot :p)
	RA(Detruire :p Place)
	RD(ImpliciteResultat :p 1)
	RA(QuestionEtTexte 114 Vrai)

] ;  Fin Place Implicite par Semi-Flot  ;

[ ;  Debut Communication Avec Macao  ;

$ RCommuniquerAvecMacao

  Si
	RE(QuestionEtTexte :Que Vrai)
  Alors
	PDebutEnsemble()
	PNumEtatQuestion(:Que)
	EstVrai(VerifierSiOnPeutContinuer)

$ RAjouterUnePlace

  Si
	(Existe :p)
	(Existe :Nom)
	RE(Ajouter :p Place)
	RE(Name :p :Nom)
	Vrai(AjouterUnePlace)
 Alors
	PCreerNoeud(Place :p)
	PModifAttribut(:p Name :Nom)

$ RAjouterLesArcsEnEntreeDUnePlace

  Si
	(Existe ! :p)
	(Existe ! :t)
	(Existe :v)
	(Existe :Num)
	(Existe :Sui)
	RE(Ajouter :p Place)
	Non RE(ArcEntreePlace :t :p)
	RE(Post :p :t)
	ME(Post :p :t :v)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)
	Vrai(AjouterLesArcsEnEntreeDUnePlace)
  Repete

	PCreerConnecteur(Arc :Sui :t :p)    
	PModifAttribut(:Sui Valuation :v)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(ArcEntreePlace :t :p)

$ RAjouterLesArcsEnSortieDUnePlace

  Si
	(Existe ! :p)
	(Existe ! :t)
	(Existe :v)
	(Existe :Num)
	(Existe :Sui)
	RE(Ajouter :p Place)
	Non RE(ArcSortiePlace :p :t)
	RE(Pre :p :t)
	ME(Pre :p :t :v)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)
	Vrai(AjouterLesArcsEnSortieDUnePlace)
  Repete

	PCreerConnecteur(Arc :Sui :p :t)    
	PModifAttribut(:Sui Valuation :v)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(ArcSortiePlace :p :t)

$ RAjouterUneTransition

  Si
	(Existe ! :t)
	(Existe :Nom)
	RE(Ajouter :t Transition)
	Non RE(TransitionAjoutee :t Vrai)
	RE(Name :t :Nom)
	Vrai(AjouterUneTransition)
 Repete
	PCreerNoeud(Transition :t)
	PModifAttribut(:t Name :Nom)
	RA(TransitionAjoutee :t Vrai)

$ RAjouterLesArcsEnEntreeDUneTransition

  Si
	(Existe ! :p)
	(Existe ! :t)
	(Existe :v)
	(Existe :Num)
	(Existe :Sui)
	RE(Ajouter :t Transition)
	Non RE(ArcEntreeTransition :p :t)
	RE(Pre :p :t)
	ME(Pre :p :t :v)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)
	Vrai(AjouterLesArcsEnEntreeDUneTransition)
  Repete

	PCreerConnecteur(Arc :Sui :p :t)    
	PModifAttribut(:Sui Valuation :v)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(ArcEntreeTransition :p :t)

$ RAjouterLesArcsEnSortieDUneTransition

  Si
	(Existe ! :p)
	(Existe ! :t)
	(Existe :v)
	(Existe :Num)
	(Existe :Sui)
	RE(Ajouter :t Transition)
	Non RE(ArcSortieTransition :t :p)
	RE(Post :p :t)
	ME(Post :p :t :v)
	RE(RelNum Objet :Num)
	Plus(:Sui :Num 1)
	Vrai(AjouterLesArcsEnSortieDUneTransition)
  Repete

	PCreerConnecteur(Arc :Sui :t :p)    
	PModifAttribut(:Sui Valuation :v)
	RD(RelNum Objet :Num)
	RA(RelNum Objet :Sui)
	RA(ArcSortieTransition :t :p)

$ RSupprimerUnePlace

  Si
	(Existe :Obj)
	RE(Detruire :Obj Place)
  Alors
	PDetruitObjet(:Obj)
	RDO(:Obj) 

$ RSupprimerUneTransition

  Si
	(Existe :Obj)
	RE(Detruire :Obj Transition)
  Alors
	PDetruitObjet(:Obj)
	RDO(:Obj) 

$ RFinirDeCommuniquerAvecMacao

  Si
	Vrai(VerifierSiOnPeutContinuer)
  Alors
	PFinEnsemble()
	RD(QuestionEtTexte)
	RD(Ajouter)
	RD(Detruire)
	RD(ArcEntreePlace)
	RD(ArcSortiePlace)
	RD(TransitionAjoutee)
	RD(ArcEntreeTransition)
	RD(ArcSortieTransition)
	EstFaux(AjouterUnePlace)
	EstFaux(AjouterLesArcsEnEntreeDUnePlace)
	EstFaux(AjouterLesArcsEnSortieDUnePlace)
	EstFaux(AjouterUneTransition)
	EstFaux(AjouterLesArcsEnEntreeDUneTransition)
	EstFaux(AjouterLesArcsEnSortieDUneTransition)

] ;  Fin Communication Avec Macao  ;

$ RVerifierSiOnPeutContinuer

  Si
	Vrai(VerifierSiOnPeutContinuer)
	Vrai(Saturation)
  Alors
	EstVrai(ReductionTest)
	EstFaux(VerifierSiOnPeutContinuer)

$ RInterReduction

  SiPasAutre
	Vrai(Fin)
  Alors
	RA(Reussite Reduction Vrai)
	Oublie()
